<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>3. Usando el intérprete de Python &mdash; Tutorial de Python v2.6.2 documentation</title>
    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '#',
        VERSION:     '2.6.2',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <link rel="top" title="Tutorial de Python v2.6.2 documentation" href="index.html" />
    <link rel="next" title="4. Una introducción informal a Python" href="introduction.html" />
    <link rel="prev" title="2. Abriendo tu apetito" href="appetite.html" /> 
  </head>
  <body>
    <div class="related">
      <h3>Navegación</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Índice General"
             accesskey="I">índice</a></li>
        <li class="right" >
          <a href="introduction.html" title="4. Una introducción informal a Python"
             accesskey="N">siguiente</a> |</li>
        <li class="right" >
          <a href="appetite.html" title="2. Abriendo tu apetito"
             accesskey="P">anterior</a> |</li>
        <li><a href="contenido.html">Tutorial de Python v2.6.2 documentation</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="usando-el-interprete-de-python">
<span id="tut-using"></span><h1>3. Usando el intérprete de Python<a class="headerlink" href="#usando-el-interprete-de-python" title="Enlazar permanentemente con este título">¶</a></h1>
<div class="section" id="invocando-al-interprete">
<span id="tut-invoking"></span><h2>3.1. Invocando al intérprete<a class="headerlink" href="#invocando-al-interprete" title="Enlazar permanentemente con este título">¶</a></h2>
<p>Por lo general, el intérprete de Python se instala en
file:<cite>/usr/local/bin/python</cite> en las máquinas dónde está disponible; poner
<tt class="docutils literal"><span class="pre">/usr/local/bin</span></tt> en el camino de búsqueda de tu intérprete de comandos
Unix hace posible iniciarlo ingresando la orden:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">python</span>
</pre></div>
</div>
<p>...en la terminal.  Ya que la elección del directorio dónde vivirá el
intérprete es una opción del proceso de instalación, puede estar en otros
lugares; consultá a tu Gurú Python local o administrador de sistemas. (Por
ejemplo, <tt class="docutils literal"><span class="pre">/usr/local/python</span></tt> es una alternativa popular).</p>
<p>En máquinas con Windows, la instalación de Python por lo general se encuentra
en <tt class="docutils literal"><span class="pre">C:\Python26</span></tt>, aunque se puede cambiar durante la instalación.  Para
añadir este directorio al camino, podes ingresar la siguiente orden en el
prompt de DOS:</p>
<div class="highlight-python"><pre>set path=%path%;C:\python26</pre>
</div>
<p>Se puede salir del intérprete con estado de salida cero ingresando el carácter
de fin de archivo (<tt class="docutils literal"><span class="pre">Control-D</span></tt> en Unix, <tt class="docutils literal"><span class="pre">Control-Z</span></tt> en Windows) en el
prompt primario.  Si esto no funciona, se puede salir del intérprete
ingresando: <tt class="docutils literal"><span class="pre">import</span> <span class="pre">sys;</span> <span class="pre">sys.exit()</span></tt>.</p>
<p>Las características para editar líneas del intérprete no son muy sofisticadas.
En Unix, quien instale el intérprete tendrá habilitado el soporte para la
biblioteca GNU readlines, que añade una edición interactiva más elaborada e
historia.  Tal vez la forma más rápida de detectar si las características de
edición están presentes es ingresar Control-P en el primer prompt de Python que
aparezca.  Si se escucha un beep, las características están presentes; ver
Apéndice <a class="reference external" href="interactive.html#tut-interacting"><em>Edición de entrada interactiva y sustitución de historial</em></a> para una introducción a las teclas.  Si no pasa
nada, o si aparece <tt class="docutils literal"><span class="pre">^P</span></tt>, estas características no están disponibles; solo vas
a poder usar backspace para borrar los caracteres de la línea actual.</p>
<p>La forma de operar del intérprete es parecida a la línea de comandos de
Unix: cuando se la llama con la entrada estándar conectada a una terminal
lee y ejecuta comandos en forma interactiva; cuando es llamada con un nombre de
archivo como argumento o con un archivo como entrada estándar, lee y ejecuta
un <em>script</em> del archivo.</p>
<p>Una segunda forma de iniciar el intérprete es <tt class="docutils literal"><span class="pre">python</span> <span class="pre">-c</span> <span class="pre">comando</span> <span class="pre">[arg]</span> <span class="pre">...</span></tt>,
que ejecuta las sentencias en <em>comando</em>, similar a la opción <em class="xref">-c</em> de la
línea de comandos.  Ya que las sentencias de Python suelen tener espacios en
blanco u otros caracteres que son especiales en la línea de comandos, es
normalmente recomendado citar <em>comando</em> entre comillas dobles.</p>
<p>Algunos módulos de Python son también útiles como scripts.  Pueden invocarse
usando <tt class="docutils literal"><span class="pre">python</span> <span class="pre">-m</span> <span class="pre">module</span> <span class="pre">[arg]</span> <span class="pre">...</span></tt>, que ejecuta el código de <em>module</em> como
si se hubiese ingresado su nombre completo en la línea de comandos.</p>
<p>Notá que existe una diferencia entre <tt class="docutils literal"><span class="pre">python</span> <span class="pre">file</span></tt> y <tt class="docutils literal"><span class="pre">python</span> <span class="pre">&lt;file</span></tt>.
En el último caso, la entrada solicitada por el programa, como en llamadas a
<tt class="xref docutils literal"><span class="pre">input()</span></tt> y <tt class="xref docutils literal"><span class="pre">raw_input()</span></tt>, son satisfechas desde <em>file</em>.  Ya que este
archivo ya fue leído hasta el final por el analizador antes de que el programa
empiece su ejecución, se encontrará el fin de archivo enseguida.  En el primer
caso (lo que usualmente vas a querer) son satisfechas por cualquier archivo o
dispositivo que esté conectado a la entrada estándar del intérprete de Python.</p>
<p>Cuando se usa un script, a veces es útil correr primero el script y luego
entrar al modo interactivo.  Esto se puede hacer pasándole la opción
<em class="xref">-i</em> antes del nombre del script. (Esto no funciona si el script es
leído desde la entrada estándar, por la misma razón explicada en el párrafo
anterior).</p>
<div class="section" id="pasaje-de-argumentos">
<span id="tut-argpassing"></span><h3>3.1.1. Pasaje de argumentos<a class="headerlink" href="#pasaje-de-argumentos" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Cuando son conocidos por el intérprete, el nombre del script y los argumentos
adicionales son entonces pasados al script en la variable <tt class="docutils literal"><span class="pre">sys.argv</span></tt>,
una lista de cadenas de texto.  Su longitud es al menos uno; cuando ningún
script o argumentos son pasados, <tt class="docutils literal"><span class="pre">sys.argv[0]</span></tt> es una cadena vacía.  Cuando
se pasa el nombre del script con <tt class="docutils literal"><span class="pre">'-'</span></tt> (lo que significa la entrada
estándar), <tt class="docutils literal"><span class="pre">sys.argv[0]</span></tt> vale <tt class="docutils literal"><span class="pre">'-'</span></tt>.  Cuando se usa <em class="xref">-c</em> <em>command</em>,
<tt class="docutils literal"><span class="pre">sys.argv[0]</span></tt> vale <tt class="docutils literal"><span class="pre">'-c'</span></tt>.  Cuando se usa <em class="xref">-m</em> <em>module</em>,
<tt class="docutils literal"><span class="pre">sys.argv[0]</span></tt>  toma el valor del nombre completo del módulo.  Las opciones
encontradas luego de <em class="xref">-c</em> <em>command</em> o <em class="xref">-m</em> <em>module</em> no son
consumidas por el procesador de opciones de Python pero de todas formas
almacenadas en <tt class="docutils literal"><span class="pre">sys.argv</span></tt> para ser manejadas por el comando o módulo.</p>
</div>
<div class="section" id="modo-interactivo">
<span id="tut-interactive"></span><h3>3.1.2. Modo interactivo<a class="headerlink" href="#modo-interactivo" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Se dice que estamos usando el intérprete en modo interactivo, cuando los
comandos son leídos desde una terminal.  En este modo espera el siguiente
comando con el <em>prompt primario</em>, usualmente tres signos mayor-que (<tt class="docutils literal"><span class="pre">&gt;&gt;&gt;</span></tt>);
para las líneas de continuación espera con el <em>prompt secundario</em>, por defecto
tres puntos (<tt class="docutils literal"><span class="pre">...</span></tt>).  Antes de mostrar el prompt primario, el intérprete
muestra un mensaje de bienvenida reportando su número de versión y una nota de
copyright:</p>
<div class="highlight-python"><pre>python
Python 2.6 (#1, Feb 28 2007, 00:02:06)
Type "help", "copyright", "credits" or "license" for more information.
&gt;&gt;&gt;</pre>
</div>
<p>Las líneas de continuación son necesarias cuando queremos ingresar un
constructor multilínea.  Como en el ejemplo, mirá la sentencia <tt class="xref docutils literal"><span class="pre">if</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">el_mundo_es_plano</span> <span class="o">=</span> <span class="mi">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">if</span> <span class="n">el_mundo_es_plano</span><span class="p">:</span>
<span class="gp">... </span>    <span class="k">print</span> <span class="s">u&quot;¡Tené cuidado de no caerte!&quot;</span>
<span class="gp">...</span>
<span class="go">¡Tené cuidado de no caerte!</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="el-interprete-y-su-entorno">
<span id="tut-interp"></span><h2>3.2. El intérprete y su entorno<a class="headerlink" href="#el-interprete-y-su-entorno" title="Enlazar permanentemente con este título">¶</a></h2>
<div class="section" id="manejo-de-errores">
<span id="tut-error"></span><h3>3.2.1. Manejo de errores<a class="headerlink" href="#manejo-de-errores" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Cuando ocurre un error, el intérprete imprime un mensaje de error y la traza
del error.  En el modo interactivo, luego retorna al prompt primario; cuando la
entrada viene de un archivo, el programa termina con código de salida distinto
a cero luego de imprimir la traza del error. (Las excepciones manejadas por una
clausula <tt class="xref docutils literal"><span class="pre">except</span></tt> en una sentencia <tt class="xref docutils literal"><span class="pre">try</span></tt> no son errores en
este contexto).  Algunos errores son incondicionalmente fatales y causan una
terminación con código de salida distinto de cero; esto se debe a
inconsistencias internas o a que el intérprete se queda sin memoria.
Todos los mensajes de error se escriben en el flujo de errores estándar;
las salidas normales de comandos ejecutados se escriben en la salida estándar.</p>
<p>Al ingresar el caracter de interrupción (por lo general Control-C o DEL) en el
prompt primario o secundario, se cancela la entrada y retorna al prompt
primario.  <a class="footnote-reference" href="#id2" id="id1">[1]</a> Tipear una interrupción mientras un comando se están ejecutando
lanza la excepción <tt class="xref docutils literal"><span class="pre">KeyboardInterrupt</span></tt>, que puede ser manejada con una
sentencia <tt class="xref docutils literal"><span class="pre">try</span></tt>.</p>
</div>
<div class="section" id="programas-ejecutables-de-python">
<span id="tut-scripts"></span><h3>3.2.2. Programas ejecutables de Python<a class="headerlink" href="#programas-ejecutables-de-python" title="Enlazar permanentemente con este título">¶</a></h3>
<p>En los sistemas Unix y tipo BSD, los programas Python pueden convertirse
directamente en ejecutables, como programas del intérprete de comandos,
poniendo la linea:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c">#! /usr/bin/env python</span>
</pre></div>
</div>
<p>...al principio del script y dándole al archivo permisos de ejecución
(asumiendo que el intérprete están en la variable de entorno <span class="target" id="index-69"></span><strong class="xref">PATH</strong> del
usuario).  <tt class="docutils literal"><span class="pre">#!</span></tt> deben ser los primeros dos caracteres del archivo.  En
algunas plataformas, la primer línea debe terminar al estilo Unix (<tt class="docutils literal"><span class="pre">'\n'</span></tt>),
no como en Windows (<tt class="docutils literal"><span class="pre">'\r\n'</span></tt>).  Notá que el caracter numeral
<tt class="docutils literal"><span class="pre">'#'</span></tt> se usa en Python para comenzar un comentario.</p>
<p>Se le puede dar permisos de ejecución al script usando el comando
<strong>chmod</strong>:</p>
<div class="highlight-python"><pre>$ chmod +x myscript.py</pre>
</div>
<p>En sistemas Windows, no existe la noción de &#8220;modo ejecutable&#8221;.  El instalador
de Python asocia automáticamente la extensión <tt class="docutils literal"><span class="pre">.py</span></tt> con <tt class="docutils literal"><span class="pre">python.exe</span></tt> para
que al hacerle doble click a un archivo Python se corra el script.  La
extensión también puede ser <tt class="docutils literal"><span class="pre">.pyw</span></tt>, en este caso se omite la ventana con la
consola que normalmente aparece.</p>
</div>
<div class="section" id="codificacion-del-codigo-fuente">
<h3>3.2.3. Codificación del código fuente<a class="headerlink" href="#codificacion-del-codigo-fuente" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Es posible utilizar una codificación distinta a ASCII en el código fuente de
Python.  La mejor forma de hacerlo es poner otro comentario especial enseguida
después de la línea con <tt class="docutils literal"><span class="pre">#!</span></tt> para definir la codificación:</p>
<div class="highlight-python"><pre># -*- coding: encoding -*-</pre>
</div>
<p>Con esa declaración, todos los caracteres en el archivo fuente serán traducidos
utilizando la codificación <em>encoding</em>, y será posible escribir directamente
cadenas de texto literales Unicode en la codificación seleccionada.  La lista
de posibles codificaciones se puede encontrar en la Referencia de la Biblioteca
de Python, en la sección sobre <tt class="xref docutils literal"><span class="pre">codecs</span></tt>.</p>
<p>Por ejemplo, para escribir literales Unicode, incluyendo el símbolo de la
moneda Euro, se puede usar la codificación ISO-8859-15, en la que el símbolo
Euro tiene el valor 164.  Este script imprimirá el valor 8364 (el código
Unicode correspondiente al símbolo Euro) y luego saldrá:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># -*- coding: iso-8859-15 -*-</span>

<span class="n">moneda</span> <span class="o">=</span> <span class="s">u&quot;€&quot;</span>
<span class="k">print</span> <span class="nb">ord</span><span class="p">(</span><span class="n">moneda</span><span class="p">)</span>
</pre></div>
</div>
<p>Si tu editor tiene soporte para guardar archivos como <tt class="docutils literal"><span class="pre">UTF-8</span></tt> con
<em>marca de orden de byte</em> UTF-8 (también conocida como BOM), podés usar eso en
lugar de la declaración de codificación.  IDLE lo soporta si se activa
<tt class="docutils literal"><span class="pre">Options/General/Default</span> <span class="pre">Source</span> <span class="pre">Encoding/UTF-8</span></tt>.  Notá que esto no funciona
en versiones antiguas de Python (2.2 y anteriores), ni por el sistema operativo
en scripts con la línea con <tt class="docutils literal"><span class="pre">#!</span></tt> (solo usado en sistemas Unix).</p>
<p>Usando UTF-8 (ya sea mediante BOM o la declaración de codificación), los
caracteres de la mayoría de los idiomas del mundo pueden ser usados
simultáneamente en cadenas de texto o comentarios.  No se soporta usar
caracteres no-ASCII en identificadores.  Para mostrar todos estos caracteres de
forma apropiada, tu editor debe reconocer que el archivo es UTF-8, y debe usar
una tipografía que soporte todos los caracteres del archivo.</p>
</div>
<div class="section" id="el-archivo-de-inicio-interactivo">
<span id="tut-startup"></span><h3>3.2.4. El archivo de inicio interactivo<a class="headerlink" href="#el-archivo-de-inicio-interactivo" title="Enlazar permanentemente con este título">¶</a></h3>
<p>Cuando usás Python en forma interactiva, suele ser útil que algunos comandos
estándar se ejecuten cada vez que el intérprete se inicia.  Podés hacer esto
configurando la variable de entorno <span class="target" id="index-70"></span><strong class="xref">PYTHONSTARTUP</strong> con el nombre de un
archivo que contenga tus comandos de inicio.  Esto es similar al archivo
<tt class="docutils literal"><span class="pre">.profile</span></tt> en los intérpretes de comandos de Unix.</p>
<p>Este archivo es solo leído en las sesiones interactivas del intérprete, no
cuando Python lee comandos de un script ni cuando file:<cite>/dev/tty</cite> se explicita
como una fuente de comandos (que de otro modo se comporta como una sesión
interactiva).  Se ejecuta en el mismo espacio de nombres en el que los comandos
interactivos se ejecutan, entonces los objetos que define o importa pueden ser
usados sin cualificaciones en la sesión interactiva.  En este archivo también
podés cambiar los prompts <tt class="docutils literal"><span class="pre">sys.ps1</span></tt> y <tt class="docutils literal"><span class="pre">sys.ps2</span></tt>.</p>
<p>Si querés leer un archivo de inicio adicional desde el directorio actual,
podés programarlo en el archivo de inicio global usando algo como <tt class="docutils literal"><span class="pre">if</span>
<span class="pre">os.path.isfile('.pythonrc.py'):</span> <span class="pre">execfile('.pythonrc.py')</span></tt>.  Si querés usar el
archivo de inicio en un script, tenés que hacer lo siguiente en forma explícita
en el script:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">os</span>
<span class="n">nombrearchivo</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s">&#39;PYTHONSTARTUP&#39;</span><span class="p">)</span>
<span class="k">if</span> <span class="n">nombrearchivo</span> <span class="ow">and</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">isfile</span><span class="p">(</span><span class="n">nombrearchivo</span><span class="p">):</span>
    <span class="nb">execfile</span><span class="p">(</span><span class="n">nombrearchivo</span><span class="p">)</span>
</pre></div>
</div>
<p class="rubric">Footnotes</p>
<table class="docutils footnote" frame="void" id="id2" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>Un problema con el paquete GNU Readline puede evitar que funcione.</td></tr>
</tbody>
</table>
</div>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <h3><a href="contenido.html">Contenidos</a></h3>
            <ul>
<li><a class="reference external" href="#">3. Usando el intérprete de Python</a><ul>
<li><a class="reference external" href="#invocando-al-interprete">3.1. Invocando al intérprete</a><ul>
<li><a class="reference external" href="#pasaje-de-argumentos">3.1.1. Pasaje de argumentos</a></li>
<li><a class="reference external" href="#modo-interactivo">3.1.2. Modo interactivo</a></li>
</ul>
</li>
<li><a class="reference external" href="#el-interprete-y-su-entorno">3.2. El intérprete y su entorno</a><ul>
<li><a class="reference external" href="#manejo-de-errores">3.2.1. Manejo de errores</a></li>
<li><a class="reference external" href="#programas-ejecutables-de-python">3.2.2. Programas ejecutables de Python</a></li>
<li><a class="reference external" href="#codificacion-del-codigo-fuente">3.2.3. Codificación del código fuente</a></li>
<li><a class="reference external" href="#el-archivo-de-inicio-interactivo">3.2.4. El archivo de inicio interactivo</a></li>
</ul>
</li>
</ul>
</li>
</ul>

            <h4>Tema anterior</h4>
            <p class="topless"><a href="appetite.html"
                                  title="Capítulo anterior">2. Abriendo tu apetito</a></p>
            <h4>Próximo tema</h4>
            <p class="topless"><a href="introduction.html"
                                  title="Próximo capítulo">4. Una introducción informal a Python</a></p>
            <h3>Esta página</h3>
            <ul class="this-page-menu">
              <li><a href="_sources/interpreter.txt"
                     rel="nofollow">Enseñar el código</a></li>
            </ul>
          <div id="searchbox" style="display: none">
            <h3>Búsqueda rápida</h3>
              <form class="search" action="search.html" method="get">
                <input type="text" name="q" size="18" />
                <input type="submit" value="Ir a" />
                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
              </form>
              <p class="searchtip" style="font-size: 90%">
              Ingrese una palabra para buscar o un nombre de módulo, clase o función
              </p>
          </div>
          <h4><a href="/"> Volver a CdPedia </a></h4>
          <script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navegación</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Índice General"
             >índice</a></li>
        <li class="right" >
          <a href="introduction.html" title="4. Una introducción informal a Python"
             >siguiente</a> |</li>
        <li class="right" >
          <a href="appetite.html" title="2. Abriendo tu apetito"
             >anterior</a> |</li>
        <li><a href="contenido.html">Tutorial de Python v2.6.2 documentation</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
      &copy; Copyright 2009, Python Software Foundation.
      Creado con <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.5.
    </div>
  </body>
</html>
